package com.sdkj.base.common;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.UnsupportedEncodingException;
import java.math.BigDecimal;
import java.net.URL;
import java.net.URLConnection;
import java.net.URLDecoder;
import java.net.URLEncoder;
import java.text.DateFormat;
import java.text.NumberFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.zip.GZIPInputStream;
import net.sf.json.JSONArray;
import org.apache.commons.beanutils.BeanUtils;
import org.apache.commons.lang.StringUtils;
import org.apache.commons.lang.reflect.MethodUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * 公共工具类
 * <p>
 * 提供字符串、日期、数字、正则表达式以及数组一些常用操作方法，<br>
 * 具体如下：
 * <li>字符串比较、查找、截断、替代、补齐以及判空；</li>
 * <li>日期与字符串之间相互转换、日期格式化、时间相关计算；</li>
 * <li>数字与字符串之间相互转换、数字判断；</li>
 * <li>邮箱验证正则表达式、密码验证正则表达式。</li>
 * 
 * @author 雷魏平
 * @version 1.0
 */
public class HyTool {

	/**
	 * 定义常用的日期格式化对象。
	 */
	public static interface DateFmts {

		/**
		 * “yyyy年MM月dd日”格式。
		 * <p>
		 * 例：2011年4月10日
		 */
		String YYYYMMDD_CH = "yyyy年MM月dd日";

		/**
		 * “年月日”格式。
		 * <p>
		 * 例：20110410
		 */
		DateFormat YYYYMMDD = new SimpleDateFormat("yyyyMMdd");

		/**
		 * “年月日”格式。
		 * <p>
		 * 例：2011041011
		 */
		DateFormat YYYYMMDDHH = new SimpleDateFormat("yyyyMMddHH");

		/**
		 * “年-月-日”格式
		 * <p>
		 * 例：2011-04-10
		 */
		DateFormat YYYY_MM_DD = new SimpleDateFormat("yyyy-MM-dd");

		/**
		 * “年/月/日”格式
		 * <p>
		 * 例：2011/04/10
		 */
		DateFormat YYYY_MM_DD_SLASH = new SimpleDateFormat("yyyy/MM/dd");

		/**
		 * “年-月-日　时：分：秒”
		 * <p>
		 * 例：2011-04-10 18:11:39
		 */
		DateFormat YYYY_MM_DD_HHMMSS = new SimpleDateFormat(
				"yyyy-MM-dd HH:mm:ss");
        
		/**
		 * “年-月-日　时：分”
		 * <p>
		 * 例：2011-04-10 18:11
		 */
		DateFormat YYYY_MM_DD_HHMM = new SimpleDateFormat(
				"yyyy-MM-dd HH:mm");
		
		/**
		 * “年-月-日 （星期）　时：分：秒”
		 * <p>
		 * 例：2011-04-10 (星期日) 18:11:58
		 */
		DateFormat YYYY_MM_DD_EEE_HHMMSS = new SimpleDateFormat(
				"yyyy-MM-dd '('EEE')' HH:mm:ss");

		/**
		 * “时间段　时：分”
		 * <p>
		 * 例：下午 18:12
		 */
		DateFormat a_HHMM = new SimpleDateFormat("a HH:mm");

	}

	/**
	 * 定义常用的正则表达式。
	 */
	public static interface Regex {

		/**
		 * 后台添加用户验证密码
		 */
		String ADMINSAVEPASSWORD = "^[A-Za-z0-9_-]+$";
		/**
		 * 邮箱地址。
		 */
		String EMAIL = "^(\\w)+@(\\w)+((\\.\\w{2,}){1,3})$";
		/**
		 * URL地址。
		 */
		String URL = "[a-zA-z]+://[^\\s]*";

		/**
		 * 身份证号。
		 * <p>
		 * 15位或者18位的数字
		 */
		String ID = "\\d{15}|\\d{18}";

		/**
		 * 密码。
		 * <p>
		 * 6~16位数字、字母或者下划线组成。
		 */
		String PWD = "^[A-Za-z0-9_-]{6,16}$";

		/**
		 * 浮点数。
		 */
		String FLOAT = "^-?\\d+(\\.\\d+)?$";

		/**
		 * 无符号浮点数。
		 */
		String UNSIGNED_FLOAT = "^\\d+(\\.\\d+)?$";

		/**
		 * 整型。
		 */
		String INT = "^-?\\d+$";

		/**
		 * 无符号整型。
		 */
		String UNSIGNED_INT = "^\\d+$";

		/**
		 * 中文。
		 */
		String ZH_WORD = "^[\u4e00-\u9fa5]+$";

		/**
		 * 字母。
		 */
		String LETTER = "^[a-zA-Z]+$";

		/**
		 * 空格。
		 * <p>
		 * 全角空格、半角空格、制表符、换行符或者回车符号。
		 */
		String SPACE = "^[\\s\\u3000]+$";

		/**
		 * ascii字符集。
		 */
		String ASCII = "^[\\u0000-\\u00ff]+$";

	}

	private static final Logger log = LoggerFactory.getLogger(HyTool.class);

	/**
	 * 空白字符串。
	 */
	private static final String BLANK = "";

	/**
	 * 判断字符串是空白或者空格字符串。
	 * <p>
	 * 例如：<br>
	 * <li>{@code isBlank(null)  = true}</li>
	 * <li>{@code isBlank("")    = true}</li>
	 * <li>{@code isBlank("  ")  = true}</li>
	 * <li>{@code isBlank("abc") = false}</li>
	 * 
	 * @param str
	 *            待检测字符串
	 * @return {@code str}为空白或者空格字符串时返回{@code true}
	 */
	public static boolean isBlank(String str) {
		return str == null || BLANK.equals(str.trim());
	}
	
    public static boolean isObjectBlank(Object obj){
    	return obj == null || BLANK.equals(obj);
    }
    
    public static boolean isNotObjectBlank(Object obj){
    	return !isObjectBlank(obj);
    }
    
	/**
	 * 去除字符串中的空格、回车、换行符、制表符
	 * @param plainText
	 * @return
	 */
	public static String trimStrBlank(String str){

		Pattern p = Pattern.compile("\\s*|\t|\r|\n");
		Matcher m = p.matcher(str);
		return m.replaceAll("");
	}
	

	/**
	 * 判断字符串是空白或者空格字符串。
	 * <p>
	 * 例如：<br>
	 * <li>{@code isBlank(null)  = true}</li>
	 * <li>{@code isBlank("")    = true}</li>
	 * <li>{@code isBlank("  ")  = true}</li>
	 * <li>{@code isBlank("abc") = false}</li>
	 * 
	 * @param str
	 *            待检测字符串
	 * @return {@code str}为空白或者空格字符串时返回{@code true}
	 */
	public static boolean isPass(String str) {
		return str != null&&!BLANK.equals(str)&&str.length()>5;
	}
	
	/**
	 * 遇到null转成空，不是null的串去首尾空格。
	 * <p>
	 * 例如：<br>
	 * <li>{@code null2blank(null)  = ""}</li>
	 * 
	 * @param str
	 *            待检测字符串
	 * @return {@code str}为空白或者空格字符串时返回{@code true}
	 */
	public static String null2blank(String str) {
		return str == null ? "" : str.trim();
	}

	/**
	 * 判断字符串是空白。
	 * <p>
	 * 例如：<br>
	 * <li>{@code isEmpty(null)  = true}</li>
	 * <li>{@code isEmpty("")    = true}</li>
	 * <li>{@code isEmpty("  ")  = false}</li>
	 * <li>{@code isEmpty("abc") = false}</li>
	 * 
	 * @param str
	 *            待检测字符串
	 * @return {@code str}为{@code null}或者{@code ""}时返回{@code true}
	 */
	public static boolean isEmpty(String str) {
		return str == null || BLANK.equals(str);
	}

	/**
	 * 判断字符串不是空白或者空格字符串。
	 * <p>
	 * 例如：<br>
	 * <li>{@code isNotBlank(null)  = false}</li>
	 * <li>{@code isNotBlank("")    = false}</li>
	 * <li>{@code isNotBlank("  ")  = false}</li>
	 * <li>{@code isNotBlank("abc") = true}</li>
	 * 
	 * @param str
	 *            待检测字符串
	 * @return {@code str}为空白或者空格字符串时返回{@code false}
	 */
	public static boolean isNotBlank(String str) {
		return !isBlank(str);
	}
	
	public static boolean isArray(Object o) {
		return o != null && o.getClass().isArray();
	}
	
	/**
	 * 判断字符串不是空白。
	 * <p>
	 * 例如：<br>
	 * <li>{@code isNotEmpty(null)  = false}</li>
	 * <li>{@code isNotEmpty("")    = false}</li>
	 * <li>{@code isNotEmpty("  ")  = true}</li>
	 * <li>{@code isNotEmpty("abc") = true}</li>
	 * 
	 * @param str
	 *            待检测字符串
	 * @return {@code str}为{@code null}或者{@code ""}时返回{@code false}
	 */
	public static boolean isNotEmpty(String str) {
		return !isEmpty(str);
	}

	/**
	 * 对字符串进行正则匹配。<code>str</code>或者<code>pattern</code>为空时，返回<code>false</code>
	 * ，如果结果匹配不上，返回<code>false</code>，匹配成功返回<code>true</code>。
	 * <p>
	 * 例如：<br>
	 * <li>chkFmt(null, null) = false</li>
	 * <li>chkFmt("abc","^\\d+$") = false</li>
	 * <li>chkFmt("1232","^\\d+$") = true</li>
	 * 
	 * @param str
	 *            待检测字符串
	 * @param pattern
	 *            正则表达式
	 * @return 匹配结果
	 * @see Regex
	 */
	public static boolean chkFmt(String str, String pattern) {
		if (isEmpty(str) || isEmpty(pattern)) {
			return false;
		} else {
			try {
				Pattern regex = Pattern.compile(pattern);
				Matcher matcher = regex.matcher(str);
				return matcher.matches();
			} catch (Exception e) {
				return false;

			}
		}
	}

	/**
	 * 判断字符串是合法的邮箱地址。
	 * <p>
	 * 例如：<br>
	 * <li>chkEmail("a@gmail.com") = true</li>
	 * <li>chkEmail("_a@gmail.com") = false</li>
	 * <li>chkEmail(".a@gmail.com") = false</li>
	 * <li>chkEmail("-a@gmail.com") = false</li>
	 * <li>chkEmail("a_a@gmail.com") = true</li>
	 * <li>chkEmail("a-@gmail.com") = false</li>
	 * @param str
	 *            待检测字符串
	 * @return 匹配结果
	 * @see HyTool#chkFmt(String, String)
	 * @see Regex#EMAIL
	 */
	public static boolean chkEmail(String str) {
		return chkFmt(str, Regex.EMAIL);
	}

	/**
	 * 判断字符串是合法身份证号。
	 * <p>
	 * 例如：<br>
	 * <li>chkID("12345678901234") = false</li>
	 * <li>chkID("123456789012345") = true</li>
	 * 
	 * @param str
	 *            待检测字符串
	 * @return 匹配结果
	 * @see HyTool#chkFmt(String, String)
	 * @see Regex#ID
	 */
	public static boolean chkID(String str) {
		return chkFmt(str, Regex.ID);
	}

	/**
	 * 判断字符串是合法的密码。
	 * <p>
	 * 例如：<br>
	 * <li>chkPwd("afdaf132") = true</li>
	 * <li>chkPwd("143_1f3") = true</li>
	 * <li>chkPwd("143_-43") = false</li>
	 * 
	 * @param str
	 *            待检测字符串
	 * @return 匹配结果
	 * @see HyTool#chkFmt(String, String)
	 * @see Regex#PWD
	 */
	public static boolean chkPwd(String str) {
		return chkFmt(str, Regex.PWD);
	}

	/**
	 * 后台添加用户验证密码
	 * 
	 * @param str
	 * @return
	 */
	public static boolean adminChkPwd(String str) {
		return chkFmt(str, Regex.ADMINSAVEPASSWORD);
	}

	/**
	 * 判断字符串是合法的地址。
	 * <p>
	 * 例如：<br>
	 * <li>chkUrl("http://www.sina.com") = true</li>
	 * 
	 * @param str
	 *            待检测字符串
	 * @return 匹配结果
	 * @see HyTool#chkFmt(String, String)
	 * @see Regex#URL
	 */
	public static boolean chkUrl(String str) {
		return chkFmt(str, Regex.URL);
	}

	/**
	 * 判断字符串是合法的浮点数。
	 * <p>
	 * 例如：<br>
	 * <li>chkFloat("1.1") = true</li>
	 * <li>chkFloat("1.") = false</li>
	 * <li>chkFloat(".1") = false</li>
	 * <li>chkFloat("1") = true</li>
	 * <li>chkFloat("a") = false</li>
	 * 
	 * @param str
	 *            待检测字符串
	 * @return 匹配结果
	 * @see HyTool#chkFmt(String, String)
	 * @see Regex#FLOAT
	 */
	public static boolean chkFloat(String str) {
		return chkFmt(str, Regex.FLOAT);
	}

	/**
	 * 判断字符串是合法的无符号浮点数。
	 * <p>
	 * 例如：<br>
	 * <li>chkUfloat("1.1") = true</li>
	 * <li>chkUfloat("-1") = false</li>
	 * 
	 * @param str
	 *            待检测字符串
	 * @return 匹配结果
	 * @see HyTool#chkFmt(String, String)
	 * @see Regex#UNSIGNED_FLOAT
	 */
	public static boolean chkUnsignedfloat(String str) {
		return chkFmt(str, Regex.UNSIGNED_FLOAT);
	}

	/**
	 * 判断字符串是合法的整型数。
	 * <p>
	 * 例如：<br>
	 * <li>chkInt("1.1") = false</li>
	 * <li>chkInt("-1") = true</li>
	 * 
	 * @param str
	 *            待检测字符串
	 * @return 匹配结果
	 * @see HyTool#chkFmt(String, String)
	 * @see Regex#INT
	 */
	public static boolean chkInt(String str) {
		return chkFmt(str, Regex.INT);
	}

	public static boolean chkStrRange(String str, int minLen, int maxLen) {
		if (minLen < 0 || maxLen < 0 || maxLen < minLen) {
			throw new IllegalArgumentException();
		}
		if (isEmpty(str)) {
			return false;
		} else {
			int len = strlen(str);
			return len >= minLen && len <= maxLen;
		}
	}

	/**
	 * 判断字符串是合法的整型数。
	 * <p>
	 * 例如：<br>
	 * <li>chkUnsignedInt("1.1") = false</li>
	 * <li>chkUnsignedInt("-1") = false</li>
	 * <li>chkUnsignedInt("1") = true</li>
	 * 
	 * @param str
	 *            待检测字符串
	 * @return 匹配结果
	 * @see HyTool#chkFmt(String, String)
	 * @see Regex#UNSIGNED_INT
	 */
	public static boolean chkUnsignedInt(String str) {
		return chkFmt(str, Regex.UNSIGNED_INT);
	}

	/**
	 * 判断字符串是汉字串。
	 * <p>
	 * 例如：<br>
	 * <li>chkZhWord("字符串") = true</li>
	 * <li>chkZhWord("a符b") = false</li>
	 * <li>chkZhWord("1.1") = false</li>
	 * 
	 * @param str
	 *            待检测字符串
	 * @return 匹配结果
	 * @see HyTool#chkFmt(String, String)
	 * @see Regex#ZH_WORD
	 */
	public static boolean chkZhWord(String str) {
		return chkFmt(str, Regex.ZH_WORD);
	}

	/**
	 * 判断字符串是字母串。
	 * <p>
	 * 例如：<br>
	 * <li>chkLetter("abc") = true</li>
	 * <li>chkLetter("134") = false</li>
	 * 
	 * @param str
	 *            待检测字符串
	 * @return 匹配结果
	 * @see HyTool#chkFmt(String, String)
	 * @see Regex#LETTER
	 */
	public static boolean chkLetter(String str) {
		return chkFmt(str, Regex.LETTER);
	}

	/**
	 * 判断字符串是空白串。
	 * <p>
	 * 例如：<br>
	 * <li>chkSpace("\r\t\n ") = true</li>
	 * <li>chkSpace(" 134 ") 　 = false</li>
	 * <li>chkSpace(" 　 ") 　 = true</li>
	 * 
	 * @param str
	 *            待检测字符串
	 * @return 匹配结果
	 * @see HyTool#chkFmt(String, String)
	 * @see Regex#SPACE
	 */
	public static boolean chkSpace(String str) {
		return chkFmt(str, Regex.SPACE);
	}

	public static boolean chkRightSpace(String str) {
		if (str.isEmpty()) {
			return false;
		} else {
			return chkSpace(String.valueOf(str.charAt(str.length() - 1)));
		}
	}

	public static boolean chkLeftSpace(String str) {
		if (str.isEmpty()) {
			return false;
		} else {
			return chkSpace(String.valueOf(str.charAt(0)));
		}
	}

	/**
	 * 判断字符串是ascii字符串。
	 * <p>
	 * 例如：<br>
	 * <li>chkAscii("a*_ ") = true</li>
	 * <li>chkAscii("字符串") = false</li>
	 * 
	 * @param str
	 *            待检测字符串
	 * @return 匹配结果
	 * @see HyTool#chkFmt(String, String)
	 * @see Regex#SPACE
	 */
	public static boolean chkAscii(String str) {
		return chkFmt(str, Regex.ASCII);
	}

	/**
	 * 取得中英混合字符串的长度，汉字长度为2。
	 * <p>
	 * 例如：<br>
	 * <li>strlen(null) = 0</li>
	 * <li>strlen("") = 0</li>
	 * <li>strlen("1串0") = 4</li>
	 * 
	 * @param str
	 *            中英混合字符串
	 * @return 字符串长度。
	 */
	public static int strlen(String str) {
		if (isEmpty(str)) {
			return 0;
		} else {
			int len = 0;
			for (int index = 0; index < str.length(); index++) {
				char c = str.charAt(index);
				if (chkAscii(String.valueOf(c))) {
					len += 1;
				} else {
					len += 2;
				}
			}
			return len;
		}
	}

	/**
	 * 返回当前日期指定<code>dateFormat</code>的字符串。
	 * <p>
	 * 例如：<br>
	 * <li>getDate(DateFmts.YYYYMMDD) = "20110408"</li>
	 * 
	 * @param dateFormat
	 *            日期格式串。
	 * @return 格式化后的日期串
	 * @see DateFmts
	 */
	public static String getDate(DateFormat dateFormat) {
		if (dateFormat == null) {
			return BLANK;
		} else {
			DateFormat dateFormatCopy = (DateFormat) dateFormat.clone();
			return dateFormatCopy.format(new Date());
		}
	}
	
	/**
	 * 返回明日日期指定<code>dateFormat</code>的字符串。
	 * <p>
	 * 例如：<br>
	 * <li>getDate(DateFmts.YYYYMMDD) = "20110408"</li>
	 * 
	 * @param dateFormat
	 *            日期格式串。
	 * @return 格式化后的日期串
	 * @see DateFmts
	 */
	public static String getTomorrowDate(DateFormat dateFormat) {
		if (dateFormat == null) {
			return BLANK;
		} else {
			Date today = new Date();
			DateFormat dateFormatCopy = (DateFormat) dateFormat.clone();
			return dateFormatCopy.format(new Date(today.getTime() + 24*60*60*1000));
			
		}
	}

	public static String getDate(String dateFormat) {
		Calendar calendar = Calendar.getInstance();
		if (DateFmts.YYYYMMDD_CH.equals(dateFormat)) {
			calendar.setTime(new Date());
			int year = calendar.get(Calendar.YEAR);
			int mon = calendar.get(Calendar.MONTH) + 1;
			int day = calendar.get(Calendar.DAY_OF_MONTH);
			return year + "年" + mon + "月" + day + "日";
		} else {
			return BLANK;
		}
	}

	/**
	 * 得到最近一个月时间
	 */
	public static Date getRecentMonth(){
		Calendar calendar = Calendar.getInstance();
		calendar.setTime(new Date());
		 //得到前一天
		calendar.add(Calendar.DATE, 1);
		//得到前一个月
		calendar.add(Calendar.MONTH, -1);
		return calendar.getTime();
	}
	
	/**
	 * 得到当前月的开始时间
	 */
	public static String getCurrentMonthFirstDay() {     
	    Calendar calendar = Calendar.getInstance();     
	    calendar.set(Calendar.DAY_OF_MONTH, calendar.getActualMinimum(Calendar.DAY_OF_MONTH));	  
	    return HyTool.getDate(HyTool.DateFmts.YYYY_MM_DD,calendar.getTime()); 
	}
	
	/**
	 * 得到当前时间的年
	 */
	public static  int getYear() {
		Calendar cal = Calendar.getInstance();
		int year = cal.get(Calendar.YEAR);
		return year;
	}
	
	/**
	 * 得到当前时间的月份
	 */
	public static  int getMonth() {
		Calendar cal = Calendar.getInstance();
		int month = cal.get(Calendar.MONTH)+1;
		return month;
	}
	
	/**
	 * 得到指定年月的当前月的开始时间
	 */
	public static String getMonthFirstDay(int year, int month ) {     
	    Calendar calendar = Calendar.getInstance();  
	    calendar.set(Calendar.YEAR, year);  
	    calendar.set(Calendar.MONTH, month); 
	    calendar.set(Calendar.DAY_OF_MONTH, calendar.getActualMinimum(Calendar.DAY_OF_MONTH));	  
	    return HyTool.getDate(HyTool.DateFmts.YYYY_MM_DD,calendar.getTime()); 
	}
	/**
	 * 得到指定年月的最后一天
	 */
	public static String getLastDayOfMonth(int year, int month) {  
        Calendar cal = Calendar.getInstance();  
        cal.set(Calendar.YEAR, year);  
        cal.set(Calendar.MONTH, month);  
        // 某年某月的最后一天  
        cal.set(Calendar.DAY_OF_MONTH, cal.getActualMaximum(Calendar.DAY_OF_MONTH));	
        return HyTool.getDate(HyTool.DateFmts.YYYY_MM_DD,cal.getTime());  
    } 
	
	public static String getDate(DateFormat dateFormat, Date date) {
		if (dateFormat == null || date == null) {
			return BLANK;
		} else {
			DateFormat dateFormatCopy =  (DateFormat)dateFormat.clone();
			return dateFormatCopy.format(date);
		}
	}

	public static String getDate(String dateFormat, Date date) {
		Calendar calendar = Calendar.getInstance();
		if (dateFormat == null || date == null) {
			return BLANK;
		} else {
			if (DateFmts.YYYYMMDD_CH.equals(dateFormat)) {
				calendar.setTime(date);
				int year = calendar.get(Calendar.YEAR);
				int mon = calendar.get(Calendar.MONTH) + 1;
				int day = calendar.get(Calendar.DAY_OF_MONTH);
				int hour = calendar.get(Calendar.HOUR)+1;
				return year + "年" + mon + "月" + day + "日";
			} else {
				return BLANK;
			}
		}
	}

	/**
	 * 返回今天若干天前的日期，如果{@code days}为负，那就是几天之后，反之就是几天之前。
	 * <p>
	 * 例如：<br>
	 * <li>new Date() = "Sun Apr 10 20:02:00 CST 2011"</li>
	 * <li>getDateDaysAgo(1) = "Mon Apr 11 20:02:00 CST 2011"</li>
	 * <li>getDateDaysAgo(-1)= "Sat Apr 09 20:02:00 CST 2011"</li>
	 * 
	 * @param days
	 *            若干天
	 * @return 若干天前的日期
	 */
	public static Date getDateDaysAgo(int days) {
		Calendar calendar = Calendar.getInstance();
		calendar.add(Calendar.DAY_OF_YEAR, -days);
		return calendar.getTime();
	}
	
	public static String getDateHoursAgo(int hours,int hour){
		Calendar calendar = Calendar.getInstance();
		if(hour != 23){
			calendar.add(Calendar.HOUR, -hours);
			return getDate(DateFmts.YYYYMMDDHH,calendar.getTime());
		}else{
			Integer nowdate = Integer.parseInt(getDate(DateFmts.YYYYMMDDHH, new Date()))+1;
			return nowdate.toString();
		}
	}

	/**
	 * 取得混合字符串中从start位置开始到end-1位置结束的子串。
	 */
	public static final String substr(String str, int start, int end) {
		if (isBlank(str) || start < 0 || end < 0 || end <= start) {
			return BLANK;
		}

		int len = strlen(str);
		if (len < start) {
			return BLANK;
		}
		end = end > len ? len : end;

		String substr = BLANK;
		int count = 0;
		for (int i = 0; i < str.length(); i++) {
			String ch = String.valueOf(str.charAt(i));
			if (chkAscii(ch)) {
				count += 1;
			} else {
				count += 2;
			}

			if (count > start) {
				if (count <= end) {
					substr += ch;
				} else {
					break;
				}
			}
		}

		return substr;
	}

	/**
	 * 截取从头开始length长度的子串。
	 */
	public static final String substring(String str, int length) {
		return substr(str, 0, length);
	}

	/**
	 * 截取从头开始length长度的子串，子串长度小于原串则拼接concatStr。
	 */
	public static final String substring(String str, int length,
			String concatStr) {
		if (isBlank(str) || (length == 0)) {
			return BLANK;
		}

		String substr = null;
		;
		if (isBlank(concatStr)) {
			substr = substring(str, length);
		} else {
			int oldLen = strlen(str);
			substr = substring(str, length);

			// 字符串经过截取处理 ，向后拼接一个连接串。
			if (strlen(substr) < oldLen) {
				substr += concatStr;
			}
		}

		return substr;
	}

	public static String getWebZipContent(String url, String encoding) {
		return getWebContent(url, encoding, true);
	}

	public static String getWebContent(String url, String encoding) {
		return getWebContent(url, encoding, false);
	}

	public static String getWebContent(String url, String encoding,
			boolean isGZIP) {
		if (isBlank(url)) {
			return BLANK;
		}
		int retry = 0;

		// 连接最多重试10次，每次间隔10秒。
		while (retry < 10) {
			log.warn("第" + (retry + 1) + "次连接url地址" + url);
			URL link;
			URLConnection urlConn;
			BufferedReader reader = null;
			StringBuffer content = new StringBuffer();
			try {
				// 建立url连接
				link = new URL(url);
				urlConn = link.openConnection();

				if (isGZIP) {
					reader = new BufferedReader(new InputStreamReader(
							new GZIPInputStream(urlConn.getInputStream()),
							encoding));
				} else {
					reader = new BufferedReader(new InputStreamReader(
							urlConn.getInputStream(), encoding));
				}

				String line = null;
				if ((line = reader.readLine()) != null) {
					content.append(line);
				}
				while ((line = reader.readLine()) != null) {
					content.append("\n").append(line);
				}

				// 增加这个代码原因：
				// 在访问BI实时数据接口时，BI接口会访问NUTCH接口，而NUTCH会不定时重启，导致BI读不到数据
				// BI此时会返回空白给UI，UI此时做重新访问！
				if (HyTool.isBlank(content.toString())) {
					retry++;
					try {
						Thread.sleep(10000);
					} catch (Exception e) {
					}
					continue;
				} else {
					log.warn("从url地址取得数据成功!");
					return content.toString();
				}
			} catch (Exception e) {
				log.warn("url连接中异常！", e);
				retry++;
				try {
					Thread.sleep(10000);
				} catch (InterruptedException e1) {
				}
				continue;
			} finally {
				if (reader != null) {
					try {
						reader.close();
					} catch (IOException e) {
					}
				}
			}
		}
		log.warn("从url地址取得数据失败!");
		return BLANK;
	}

	public static Date parse2Date(DateFormat dateFormat, String date) {
		if (dateFormat == null || isBlank(date)) {
			return null;
		} else {
			try {
				DateFormat dateFormatCopy = (DateFormat) dateFormat.clone();
				return dateFormatCopy.parse(date);
			} catch (ParseException e) {
				e.printStackTrace();
				return null;
			}
		}
	}

	/**
	 * 改变日期串的格式，从{@code oldFmt}转化成{@code newFmt}格式。
	 * <p>
	 * 例如：<br>
	 * <li>changeDateFmt("20100911",DateFmts.YYYYMMDD, DateFmts.YYYY_MM_DD) =
	 * 2010-09-11</li>
	 * 
	 * @param str
	 *            日期串
	 * @param oldFmt
	 *            旧日期格式
	 * @param newFmt
	 *            新日期格式
	 * @return 新日期串
	 * @see DateFmts
	 */
	public static String changeDateFmt(String str, DateFormat oldFmt,
			DateFormat newFmt) {
		if (oldFmt == null || newFmt == null) {
			return str;
		} else if (isEmpty(str)) {
			return BLANK;
		} else {
			try {
				DateFormat oldFmtCopy = (DateFormat) oldFmt.clone();
				Date date = oldFmtCopy.parse(str);
				DateFormat newFmtCopy = (DateFormat) newFmt.clone();
				return newFmt.format(date);
			} catch (Exception e) {
				return str;
			}
		}
	}

	/**
	 * 字符串{@code null}替换。
	 * <p>
	 * 例如：<br>
	 * <li>{@code replaceNull(null)  = ""}</li>
	 * <li>{@code replaceNull("")    = ""}</li>
	 * <li>{@code replaceNull("abc") = "abc"}</li>
	 * @param str
	 *            待替代字符串
	 * @return {@code str}为{@code null}时，返回{@code BLANK}
	 */
	public static String replaceNull(String str) {
		if (str == null) {
			return BLANK;
		} else {
			return str;
		}
	}

	public static String replaceNull(String str, String defaultStr) {
		if (isBlank(str)) {
			return defaultStr;
		} else {
			return str;
		}
	}

	public static <T> T replaceNull(T src, T def) {
		if (src == null) {
			return def;
		} else {
			return src;
		}
	}

	public static String replaceHTML(String str) {
		if (isBlank(str)) {
			return str;
		} else {
			return str.replaceAll("<[^>]*>", BLANK);
		}
	}

	/**
	 * 截断前后空白字符。
	 * <p>
	 * 例如：<br>
	 * <li>{@code trim("  abc\r\n")  = "abc"}</li>
	 * <li>{@code trim("\tdf 　")    = "df"}</li>
	 * 
	 * @param str
	 *            待阶段字符串
	 * @return 截断后的字符串
	 * @see HyTool#chkSpace(String)
	 */
	public static String trim(String str) {
		if (isEmpty(str) || chkSpace(str)) {
			return BLANK;
		} else {
			int len = str.length();
			int start = 0;

			// 计算前面空白的结束位置
			while (start < len && chkSpace(String.valueOf(str.charAt(start)))) {
				start++;
			}

			// 计算后面空白的开始位置
			int end = str.length();
			while (end > 0 && chkSpace(String.valueOf(str.charAt(end - 1)))) {
				end--;
			}

			return str.substring(start, end);
		}
	}

	/**
	 * 返回按照指定长度截取的String
	 * 
	 * @param String
	 *            　str String
	 * @param int　length 半角String的长度
	 * @return String rtnStr 截取后的String
	 */
	public static final String getSuitableStr(String str, int length) {

		if ((str == null) || ("".equals(str)) || (length == 0)) {

			return "";

		}

		// 返回值
		String rtnStr = null;
		// 换行flag的索引
		int enterIndex = 0;
		// 截取String開始的索引
		int startIndex = length / 2;

		int lengthCounter = 0;

		try {

			str = trim(str);

			if (strlen(str) <= (length)) {

				enterIndex = str.indexOf("\n");

				if (enterIndex != -1) {

					str = str.substring(0, enterIndex);
				}
				return str;
			}

			String headStr = str.substring(0, startIndex);

			String BuffStr = null;

			lengthCounter = strlen(headStr);

			StringBuffer rtnStrbff = new StringBuffer(headStr);

			enterIndex = headStr.indexOf("\n");

			if (enterIndex != -1) {

				rtnStr = str.substring(0, enterIndex);

				return rtnStr;
			}

			str = str.substring(startIndex);

			while (lengthCounter < length) {

				BuffStr = str.substring(0, 1);

				if ("\n".equals(BuffStr)) {
					rtnStr = rtnStrbff.toString();
					return rtnStr;
				}

				lengthCounter = lengthCounter + strlen(BuffStr);

				if (lengthCounter > length) {
					break;
				}
				rtnStrbff.append(BuffStr);

				str = str.substring(1);
			}

			rtnStr = rtnStrbff.toString();

		} catch (Exception e) {

			e.printStackTrace();

			return "";
		}
		// 在String尾部增加"..."
		return rtnStr + "...";
	}

	/**
	 * Base64加密(UTF-8)
	 * 
	 * @param bstr
	 * @return String
	 */
	public static String base64Encode(String bstr) {
		String encodeStr = null;
		try {
			encodeStr = new sun.misc.BASE64Encoder().encode(bstr
					.getBytes(BizCode.GLOBAL_ENCODING));
		} catch (UnsupportedEncodingException e) {
		}
		return encodeStr;
	}

	/**
	 * Base64解码(UTF-8)
	 * 
	 * @param str
	 * @return string
	 */
	public static String base64Decode(String str) {
		String decodeStr = null;
		byte[] bt = null;
		try {
			sun.misc.BASE64Decoder decoder = new sun.misc.BASE64Decoder();
			bt = decoder.decodeBuffer(str);
			decodeStr = new String(bt, BizCode.GLOBAL_ENCODING);
		} catch (IOException e) {
		}
		return decodeStr;
	}

	public static Byte str2Byte(String str) {
		Byte b = null;
		if (isNotBlank(str)) {
			try {
				b = Byte.valueOf(str);
			} catch (NumberFormatException e) {
			}
		}
		return b;
	}

	public static Integer str2Byte(String str, int defaultVal) {
		Byte b = str2Byte(str);
		return b == null ? defaultVal : b;
	}

	public static Integer str2Int(String str) {
		Integer i = null;
		if (isNotBlank(str)) {
			try {
				i = Integer.valueOf(str);
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
		return i;
	}

	public static Integer str2Int(String str, int defaultVal) {
		Integer i = str2Int(str);
		return i == null ? defaultVal : i;
	}

	public static Long str2Long(String str) {
		Long l = null;
		if (isNotBlank(str)) {
			try {
				l = Long.valueOf(str);
			} catch (NumberFormatException e) {
			}
		}
		return l;
	}

	public static Long str2Long(String str, long defaultVal) {
		Long l = str2Long(str);
		return l == null ? defaultVal : l;
	}

	public static Float str2Float(String str) {
		Float f = null;
		if (isNotBlank(str)) {
			try {
				f = Float.valueOf(str);
			} catch (NumberFormatException e) {
			}
		}
		return f;
	}

	public static Float str2Float(String str, float defaultVal) {
		Float f = str2Float(str);
		return f == null ? defaultVal : f;
	}

	public static String join(List list, String joinStr) {
		if (list == null || list.isEmpty()) {
			return BLANK;
		}

		joinStr = replaceNull(joinStr);
		StringBuffer result = new StringBuffer();
		result.append(list.get(0));
		for (int i = 1; i < list.size(); i++) {
			result.append(joinStr);
			result.append(list.get(i));
		}
		return result.toString();
	}
	
	/**
	 * 将1,2,3格式的数据转化为'1','2','3'格式
	 * @param str
	 * @return
	 * @author lwp
	 */
	public static String commaToSingle(String str){
		if(isEmpty(str)){
			return BLANK;
		}
		StringBuffer newStr = new StringBuffer();
		String[] array = str.split(",");
		for(String oldStr : array){
			newStr.append("'").append(oldStr).append("'").append(",");
		}
		return newStr.substring(0,newStr.length()-1).toString();
	}
	
	public static String join(List list, String fieldName, String joiner) {
		if (isListEmpty(list)) {
			return BLANK;
		}
		try {
			StringBuffer result = new StringBuffer();

			Object target = null;
			Object fieldValue = null;
			String methodName = "get" + StringUtils.capitalize(fieldName);

			int index = 0;
			for (; index < list.size() - 1; index++) {
				target = list.get(index);
				fieldValue = MethodUtils.invokeMethod(target, methodName, null);
				result.append(fieldValue == null ? BLANK : fieldValue);
				result.append(joiner);
			}
			target = list.get(index);
			fieldValue = MethodUtils.invokeMethod(target, methodName, null);
			result.append(fieldValue == null ? BLANK : fieldValue);
			
			return result.toString();
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
	}
	
	/**
	 * 将字符串数组转为','号隔开的字符串。
	 * 
	 * @author zhoujie
	 * @return String
	 */
	public static String arrayToString(String[] array) {
		StringBuffer str = new StringBuffer();
		for (int i = 0; i < array.length; i++) {
			str.append(array[i]).append(",");
		}
		String str1 = str.substring(0, str.length() - 1);
		return str1;
	}
	
	/**
	 * 将字符串数组转为','号隔开的字符串。
	 * 
	 * @author zhoujie
	 * @return String
	 */
	public static String arrayToString(String array) {
		String str = array;
		if(isNotEmpty(str)){
			if(array.contains("[")){
				str = array.substring(1, array.length());
			}
			if(array.contains("]")){
				str = str.substring(0, str.length()-1);
			}
		}
		return str;
	}

	public static boolean isListEmpty(List list) {
		return list == null || list.isEmpty();
	}

	/**
	 * 将String以逗号隔开的类型转换成Long泛型的数组
	 * @param str
	 * @return list
	 * @author leiweiping
	 */
	public static List<String> StringToStringList(String str){
		List<String> list = new ArrayList<String>();
		if(isNotEmpty(str)){
			String[] array = str.split(",");
			for(int i=0;i<array.length;i++){
				if(isNotEmpty(array[i])){
					list.add(array[i].toString());
				}
			}
		}
		return list;
	}
	
	/**
	 * 将String以逗号隔开的类型转换成Long泛型的数组
	 * @param str
	 * @return list
	 * @author leiweiping
	 */
	public static String StringToLong(String str){
		String str1 = "";
		if(isNotEmpty(str)){
			String[] array = str.split(",");
			for(int i=0;i<array.length;i++){
				if(isNotEmpty(array[i])){
					str1 += Long.parseLong(array[i].toString())+",";
				}
			}
		}
		return str1;
	}
	
	/**
	 * 四舍五入。
	 * 
	 * scale 保留的位数。
	 */
	public static BigDecimal round(Object d, int scale) {
		if (d == null) {
			d = "0";
		}
		BigDecimal b = new BigDecimal(d.toString());
		return b.setScale(scale, BigDecimal.ROUND_HALF_UP);
	}
	
	/**
	 * 不四舍五入,直接按scale指定位数返回
	 * @param d
	 * @param scale
	 * @return
	 * @throws Exception 
	 */
	public static BigDecimal roundDown(Object d, int scale){
		
		if(d == null){
			d = "0";
		}
		
		BigDecimal b = new BigDecimal(d.toString());
		return b.setScale(scale, BigDecimal.ROUND_DOWN);
	}

	/**
	 * 组合页面的日期和小时，返回一个完成的Date数据
	 * 
	 * @param date
	 * @param hours
	 * @return Date
	 */
	public static Date returnDate(String date, String hours, String mins,
			String seconds) {
		// 判断用户选择的小时长度是否为2，为1的话补0
		if (hours.length() > 0 && hours.length() < 2) {
			hours = "0" + hours;
		}
		// 组装yyyy-MM-dd hh:mm:ss格式的数据
		String nowdate = date + " " + hours + ":" + mins + ":" + seconds;
		// 默认日期是明天的日期
		Date date1 = getDateDaysAgo(-1);
		try {
			// 返回yyyy-MM-dd hh:mm:ss格式的日期数据
			date1 = parse2Date(DateFmts.YYYY_MM_DD_HHMMSS, nowdate);
		} catch (Exception e) {
			// 有异常返回yyyy-MM-dd hh:mm:ss格式的明天日期
			date1 = HyTool.parse2Date(DateFmts.YYYY_MM_DD_HHMMSS, HyTool.getDate(
					DateFmts.YYYY_MM_DD_HHMMSS, getDateDaysAgo(-1)));
		}
		return date1;
	}

	/**
	 * 编码
	 * 
	 * @param str
	 * @return String
	 * @author lwp
	 */
	public static String encodeHtml(String str) {
		str = str.replaceAll("&", "&amp;");
		str = str.replaceAll("'", "''");
		str = str.replaceAll("\"", "&quot;");
		str = str.replaceAll(" ", "&nbsp;");
		str = str.replaceAll("<", "&lt;");
		str = str.replaceAll(">", "&gt;");
		str = str.replaceAll("\n", "<br>");
		return str;
	}

	/**
	 * 编码
	 * 
	 * @param str
	 * @return String
	 * @author lwp
	 */
	public static String urlCloud(String str) {
		System.out.println(str);
		return str;
	}
	/**
	 * 解码
	 * 
	 * @param str
	 * @return String
	 * @author lwp
	 */
	public static String decodeHtml(String str) {
		str = str.replaceAll("&amp;", "&");
		str = str.replaceAll("''", "'");
		str = str.replaceAll("&quot;", "\"");
		str = str.replaceAll("&nbsp;", " ");
		str = str.replaceAll("&gt;", ">");
		str = str.replaceAll("&lt;", "<");
		str = str.replaceAll("<br>", "\n");
		return str;
	}

	public static void main(String[] args) throws IOException {

	}
	
	/**
	 * mysql关键字转译
	 * @author peter
	 */
	public static String decodeMysql(String keyword){
		keyword = keyword.replace("\\", "\\\\\\");	
		keyword = keyword.replaceAll("%", "\\%");
		keyword = keyword.replaceAll("\\'", "\\\\'");
		keyword = keyword.replace(";", "\\;");
		keyword = keyword.replaceAll("\\{", "\\\\{");
		keyword = keyword.replaceAll("\\}", "\\\\}");
		keyword = keyword.replaceAll("\\\"", "\\\\\"");
		keyword = keyword.replaceAll("\\_", "\\\\\\\\_");
		return keyword;
	}
	
	/**
	 * 封装参数组成一个URL
	 * 
	 * @param map
	 *            所有参数的map集合
	 * @return String url参数
	 * @see Map#entrySet()
	 * @author lwp
	 */
	public static String createUrl(Map map) {
		if (map == null) {
			return BLANK;
		}
		StringBuffer urlStrBuf = new StringBuffer();
		Set<Entry<String, Object>> entrySet = map.entrySet();
		Iterator<Entry<String, Object>> itr = entrySet.iterator();
		while (itr.hasNext()) {
			Entry<String, Object> entry = itr.next();
			urlStrBuf.append(entry.getKey());
			urlStrBuf.append("=");
			urlStrBuf.append(entry.getValue());
			urlStrBuf.append("&");
		}
		String urlStr = urlStrBuf.toString();
		if (isNotBlank(urlStr)) {
			urlStr = urlStr.substring(0, urlStr.length() - 1);
		}
		return urlStr;
	}

	public static String lpadZero(Object o, int bits) {
		return lpad(o, bits, '0');
	}

	public static String lpad(Object o, int bits, char c) {
		String s = String.valueOf(o);
		int repeat;
		if (o == null || isBlank(s)) {
			repeat = bits;
			s = BLANK;
		} else {
			repeat = bits - s.length();
		}
		StringBuffer newS = new StringBuffer();
		for (int time = 0; time < repeat; time++) {
			newS.append(c);
		}
		newS.append(s);
		return newS.toString();
	}

	public static String encode(String info, String code) {
		try {
			return URLEncoder.encode(info, code);
		} catch (UnsupportedEncodingException e) {
			
			e.printStackTrace();
			return info;
		}
	}

	public static String decode(String s, String code) {
		try {
			return URLDecoder.decode(s, code);
		} catch (UnsupportedEncodingException e) {
			
			e.printStackTrace();
			return s;
		}
	}

	/**
	 * 克隆javaBean。
	 * 
	 * @param bean
	 *            javaBean对象
	 * @return 新javaBean对象
	 * @see BeanUtils#cloneBean(Object)
	 * @see IllegalArgumentException
	 */
	public static Object cloneBean(Object bean) {
		try {
			return BeanUtils.cloneBean(bean);
		} catch (Exception e) {
			throw new IllegalArgumentException("bean对象不合法！", e);
		}
	}

	/**
	 * 克隆Map。
	 * 
	 * @param map
	 *            map对象
	 * @return 新map对象
	 * @see HashMap
	 * @see Hashtable
	 * @see IllegalArgumentException
	 */
	public static <K, V> Map<K, V> cloneMap(Map<K, V> map) {
		Map<K, V> newMap = null;
		if (map instanceof HashMap) {
			newMap = new HashMap<K, V>();
		} else if (map instanceof Hashtable) {
			newMap = new Hashtable<K, V>();
		} else {
			throw new IllegalArgumentException("不支持非HashMap以及Hashtable对象！");
		}
		newMap.putAll(map);
		return newMap;
	}

	/**
	 * 防止工具类被实例化。
	 */
	private HyTool() {
	}

	public static boolean str2Bool(String bool) {
		 if (isBlank(bool)) {
			 return false;
		 } else {
			 return Boolean.parseBoolean(bool);
		 }
	 }
	
	/**
	 * URL编码。
	 * 
	 * @param s
	 *            URL字符串
	 * @param enc
	 *            编码方式
	 * @return 编码后的URL字符串。
	 */
	public static String encodeURL(String s, String enc) {
		if (isBlank(s) || isBlank(enc)) {
			return s;
		}
		try {
			return URLEncoder.encode(s, enc);
		} catch (Exception e) {
			return s;
		}
	}
	
	/**
	 * URL解码。
	 * 
	 * @param s
	 *            URL字符串
	 * @param enc
	 *            编码方式
	 * @return 编码后URL字符串
	 */
	public static String decodeURL(String s, String enc) {
		if (isBlank(s) || isBlank(enc)) {
			return s;
		}
		try {
			return URLDecoder.decode(s, enc);
		} catch (Exception e) {
			return s;
		}
	}
	
	/**
	 * Ensure that the first character of the provided string is upper case.
	 *
	 * @param source The <code>String</code> to capitalize.
	 * @return The capitalized <code>String</code>.
	 * @since 1.0
	 */
	public static String capitalize(String source)
	{
		if (source == null || source.length() == 0)
		{
			return source;
		}

		if (source.length() > 1 &&
			Character.isUpperCase(source.charAt(0)))
		{
			return source;
		}

		char chars[] = source.toCharArray();
		chars[0] = Character.toUpperCase(chars[0]);
		return new String(chars);
	}
	
	/**
	 * 将UNICODE解码
	 * 
	 * @author peter
	 * @return String
	 */
	public static String unescape(String src) {
		StringBuffer tmp = new StringBuffer();
		tmp.ensureCapacity(src.length());
		int lastPos = 0, pos = 0;
		char ch;
		while (lastPos < src.length()) {
			pos = src.indexOf("%", lastPos);
			if (pos == lastPos) {
				if (src.charAt(pos + 1) == 'u') {
					ch = (char) Integer.parseInt(
							src.substring(pos + 2, pos + 6), 16);
					tmp.append(ch);
					lastPos = pos + 6;
				} else {
					ch = (char) Integer.parseInt(
							src.substring(pos + 1, pos + 3), 16);
					tmp.append(ch);
					lastPos = pos + 3;
				}
			} else {
				if (pos == -1) {
					tmp.append(src.substring(lastPos));
					lastPos = src.length();
				} else {
					tmp.append(src.substring(lastPos, pos));
					lastPos = pos;
				}
			}
		}
		return tmp.toString();
	}
	/**
	 * 得到两位数金额
	 */
	public static String getFormatPrice(float price){
		NumberFormat nf=NumberFormat.getNumberInstance() ;
		nf.setMaximumFractionDigits(2);
		String tmpPrice= nf.format(price) ; 
		return tmpPrice;
	}

	/**
	 * 解析yyyy-MM-dd_hh_mm格式的日期
	 */
	public static String formatDate(String str){
		if(isNotEmpty(str)){
			String[] dates = str.split("_");
			return dates[0]+" "+dates[1];
		}else{
			return BLANK;
		}
	}
	
	/**
	 * 字符串编码转换的实现方法 　　
	 * 
	 * @throws UnsupportedEncodingException
	 *             　　
	 */
	public static String changeCharset(String str, String oldCharset, String newCharset)
			throws UnsupportedEncodingException {
		if (str != null) {
			// 用旧的字符编码解码字符串。解码可能会出现异常。
			byte[] bs = str.getBytes(oldCharset);
			// 用新的字符编码生成字符串
			return new String(bs, newCharset);
		}
		return null;
	}
	
	public static <T> boolean equals(T t1, T t2) {
		return t1 == null ? t2 == null : t1.equals(t2);
	}
	
	public static <T> T[] toArray(T... elem) {
		return elem;
	}
	
	/**
	 * 将JSONArray转为String
	 * @param obj
	 * @param str
	 * @return String
	 */
	public static String jsonArrayToString(Object obj,String suffix){
		String str = "";
		JSONArray json = JSONArray.fromObject(obj);
		if(json.size() == 0){
			return "ALL";
		}else{
			if(isNotEmpty(suffix)){
				for(int i=0;i<json.size();i++){
					str += json.get(i)+suffix+",";
				}
			}else{
				for(int i=0;i<json.size();i++){
					str += json.get(i)+",";
				}
			}
			str = str.substring(0, str.length()-1);
			return str;
		}
	}
		
	/**
	 * 判断是否是数字
	 * @param str
	 * @return
	 */
	public static String isNumber(String str){
		try {
			Integer.parseInt(str);
			return str;
		} catch (Exception e) {
			return "0";
		}
	}
	
	/**
	 * 判断字符串长度是否合法
	 * @param str
	 * @param length
	 * @return
	 */
	public static boolean isLength(String str,int length){
		int newLength = strlen(str.trim());
		if(newLength <= length){
			return true;
		}
		return false;
	}
}